/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.gallery3d.app;

import java.lang.ref.WeakReference;
import java.util.ArrayList;

import android.app.ActionBar;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.graphics.Rect;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.HapticFeedbackConstants;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.widget.Button;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.android.gallery3d.R;
import com.android.gallery3d.common.Utils;
import com.android.gallery3d.data.DataManager;
import com.android.gallery3d.data.MediaDetails;
import com.android.gallery3d.data.MediaItem;
import com.android.gallery3d.data.MediaObject;
import com.android.gallery3d.data.MediaSet;
import com.android.gallery3d.data.Path;
import com.android.gallery3d.glrenderer.FadeTexture;
import com.android.gallery3d.glrenderer.GLCanvas;
import com.android.gallery3d.ui.ActionModeHandler;
import com.android.gallery3d.ui.ActionModeHandler.ActionModeListener;
import com.android.gallery3d.ui.AlbumSetSlotRenderer;
import com.android.gallery3d.ui.DetailsHelper;
import com.android.gallery3d.ui.DetailsHelper.CloseListener;
import com.android.gallery3d.ui.GLRoot;
import com.android.gallery3d.ui.GLView;
import com.android.gallery3d.ui.Log;
import com.android.gallery3d.ui.SelectionManager;
import com.android.gallery3d.ui.SlotView;
import com.android.gallery3d.ui.SynchronizedHandler;
import com.android.gallery3d.util.Future;
import com.android.gallery3d.util.GalleryUtils;

/**
 * 相册缩略图
 * 
 * @author lewa
 * 
 */
public class AlbumSetPage extends ActivityState implements
		SelectionManager.SelectionListener, GalleryActionBar.ClusterRunner,
		EyePosition.EyePositionListener, MediaSet.SyncListener {

	private static final String TAG = AlbumSetPage.class.getSimpleName();

	private static final int MSG_PICK_ALBUM = 1;

	public static final String KEY_MEDIA_PATH = "media-path";
	public static final String KEY_SET_TITLE = "set-title";
	public static final String KEY_SET_SUBTITLE = "set-subtitle";
	public static final String KEY_SELECTED_CLUSTER_TYPE = "selected-cluster";

	private static final int DATA_CACHE_SIZE = 256;
	private static final int REQUEST_DO_ANIMATION = 1;

	private static final int BIT_LOADING_RELOAD = 1;
	private static final int BIT_LOADING_SYNC = 2;

	private boolean mIsActive = false;
	private SlotView mSlotView;
	private AlbumSetSlotRenderer mAlbumSetView;
	private Config.AlbumSetPage mConfig;

	private MediaSet mMediaSet;
	private String mTitle;
	private String mSubtitle;
	private boolean mShowClusterMenu;
	private GalleryActionBar mActionBar;
	private int mSelectedAction;

	protected SelectionManager mSelectionManager;
	private AlbumSetDataLoader mAlbumSetDataAdapter;

	private boolean mGetContent;
	private boolean mGetAlbum;
	/**
	 * ActionBar
	 */
	private ActionModeHandler mActionModeHandler;
	/**
	 * 详细信息
	 */
	private DetailsHelper mDetailsHelper;
	private MyDetailsSource mDetailsSource;
	private boolean mShowDetails;
	private EyePosition mEyePosition;
	private Handler mHandler;

	// The eyes' position of the user, the origin is at the center of the
	// device and the unit is in pixels.
	private float mX;
	private float mY;
	private float mZ;

	private Future<Integer> mSyncTask = null;

	private int mLoadingBits = 0;
	private boolean mInitialSynced = false;

	private Button mCameraButton;
	private boolean mShowedEmptyToastForSelf = false;

	private Context mContext;
	// -----------------------Title Bar Start--
	private TextView[] titles;

	private int previousIndex = -1;

	// -----------------------Title Bar End--

	@Override
	protected int getBackgroundColorId() {
		return R.color.albumset_background;
	}

	private final GLView mRootPane = new GLView() {
		private final float mMatrix[] = new float[16];

		@Override
		protected void onLayout(boolean changed, int left, int top, int right,
				int bottom) {
			mEyePosition.resetPosition();

			int slotViewTop = mActionBar.getHeight() + mConfig.paddingTop;
			// int slotViewTop = mConfig.paddingTop;
			int slotViewBottom = bottom - top - mConfig.paddingBottom;
			int slotViewRight = right - left;

			if (mShowDetails) {
				mDetailsHelper.layout(left, slotViewTop, right, bottom);
			} else {
				mAlbumSetView.setHighlightItemPath(null);
			}
			mSlotView.layout(0, slotViewTop, slotViewRight, slotViewBottom);
		}

		@Override
		protected void render(GLCanvas canvas) {
			canvas.save(GLCanvas.SAVE_FLAG_MATRIX);
			GalleryUtils.setViewPointMatrix(mMatrix, getWidth() / 2 + mX,
					getHeight() / 2 + mY, mZ);
			canvas.multiplyMatrix(mMatrix, 0);
			super.render(canvas);
			canvas.restore();
		}
	};

	@Override
	public void onEyePositionChanged(float x, float y, float z) {
		Log.d(TAG, "onEyePositionChanged()");
		mRootPane.lockRendering();
		mX = x;
		mY = y;
		mZ = z;
		mRootPane.unlockRendering();
		mRootPane.invalidate();
	}

	@Override
	public void onBackPressed() {
		Log.d(TAG, "onBackPressed");
		if (mShowDetails) {
			hideDetails();
		} else if (mSelectionManager.inSelectionMode()) {
			mSelectionManager.leaveSelectionMode();
		} else {
			super.onBackPressed();
		}
	}

	private void getSlotCenter(int slotIndex, int center[]) {
		Log.d(TAG, "getSlotCenter()");
		Rect offset = new Rect();
		mRootPane.getBoundsOf(mSlotView, offset);
		Rect r = mSlotView.getSlotRect(slotIndex);
		int scrollX = mSlotView.getScrollX();
		int scrollY = mSlotView.getScrollY();
		center[0] = offset.left + (r.left + r.right) / 2 - scrollX;
		center[1] = offset.top + (r.top + r.bottom) / 2 - scrollY;
	}

	public void onSingleTapUp(int slotIndex) {
		Log.d(TAG, "onSingTapUp()");
		if (!mIsActive) {
			return;
		}

		if (mSelectionManager.inSelectionMode()) {
			MediaSet targetSet = mAlbumSetDataAdapter.getMediaSet(slotIndex);
			if (targetSet == null)
				return; // Content is dirty, we shall reload soon
			mSelectionManager.toggle(targetSet.getPath());
			mSlotView.invalidate();
		} else {
			// Show pressed-up animation for the single-tap.
			mAlbumSetView.setPressedIndex(slotIndex);
			mAlbumSetView.setPressedUp();
			mHandler.sendMessageDelayed(
					mHandler.obtainMessage(MSG_PICK_ALBUM, slotIndex, 0),
					FadeTexture.DURATION);
		}
	}

	private static boolean albumShouldOpenInFilmstrip(MediaSet album) {
		Log.d(TAG, "albumShouldOpenInFilmstrip()");
		int itemCount = album.getMediaItemCount();
		ArrayList<MediaItem> list = (itemCount == 1) ? album.getMediaItem(0, 1)
				: null;
		// open in film strip only if there's one item in the album and the item
		// exists
		return (list != null && !list.isEmpty());
	}

	WeakReference<Toast> mEmptyAlbumToast = null;

	private void showEmptyAlbumToast(int toastLength) {
		Toast toast;
		if (mEmptyAlbumToast != null) {
			toast = mEmptyAlbumToast.get();
			if (toast != null) {
				toast.show();
				return;
			}
		}
		toast = Toast.makeText(mActivity, R.string.empty_album, toastLength);
		mEmptyAlbumToast = new WeakReference<Toast>(toast);
		toast.show();
	}

	private void hideEmptyAlbumToast() {
		if (mEmptyAlbumToast != null) {
			Toast toast = mEmptyAlbumToast.get();
			if (toast != null)
				toast.cancel();
		}
	}

	private void pickAlbum(int slotIndex) {
		Log.d(TAG, "pickAlbum -- slotIndex : " + slotIndex);
		if (!mIsActive)
			return;

		MediaSet targetSet = mAlbumSetDataAdapter.getMediaSet(slotIndex);
		if (targetSet == null)
			return; // Content is dirty, we shall reload soon
		if (targetSet.getTotalMediaItemCount() == 0) {
			showEmptyAlbumToast(Toast.LENGTH_SHORT);
			return;
		}
		hideEmptyAlbumToast();

		String mediaPath = targetSet.getPath().toString();

		Bundle data = new Bundle(getData());
		int[] center = new int[2];
		getSlotCenter(slotIndex, center);
		data.putIntArray(AlbumPage.KEY_SET_CENTER, center);
		if (mGetAlbum && targetSet.isLeafAlbum()) {
			Activity activity = mActivity;
			Intent result = new Intent().putExtra(AlbumPicker.KEY_ALBUM_PATH,
					targetSet.getPath().toString());
			activity.setResult(Activity.RESULT_OK, result);
			activity.finish();
		} else if (targetSet.getSubMediaSetCount() > 0) {
			data.putString(AlbumSetPage.KEY_MEDIA_PATH, mediaPath);
			mActivity.getStateManager().startStateForResult(AlbumSetPage.class,
					REQUEST_DO_ANIMATION, data);
		} else {
			if (!mGetContent && albumShouldOpenInFilmstrip(targetSet)) {
				data.putParcelable(PhotoPage.KEY_OPEN_ANIMATION_RECT,
						mSlotView.getSlotRect(slotIndex, mRootPane));
				data.putInt(PhotoPage.KEY_INDEX_HINT, 0);
				data.putString(PhotoPage.KEY_MEDIA_SET_PATH, mediaPath);
				data.putBoolean(PhotoPage.KEY_START_IN_FILMSTRIP, true);
				data.putBoolean(PhotoPage.KEY_IN_CAMERA_ROLL,
						targetSet.isCameraRoll());
				mActivity.getStateManager().startStateForResult(
						FilmstripPage.class, AlbumPage.REQUEST_PHOTO, data);
				return;
			}
			data.putString(AlbumPage.KEY_MEDIA_PATH, mediaPath);

			// We only show cluster menu in the first AlbumPage in stack
			boolean inAlbum = mActivity.getStateManager().hasStateClass(
					AlbumPage.class);
			data.putBoolean(AlbumPage.KEY_SHOW_CLUSTER_MENU, !inAlbum);
			mActivity.getStateManager().startStateForResult(AlbumPage.class,
					REQUEST_DO_ANIMATION, data);
		}
	}

	private void onDown(int index) {
		Log.d(TAG, "onDown");
		mAlbumSetView.setPressedIndex(index);
	}

	private void onUp(boolean followedByLongPress) {
		Log.d(TAG, "onUp");
		if (followedByLongPress) {
			// Avoid showing press-up animations for long-press.
			mAlbumSetView.setPressedIndex(-1);
		} else {
			mAlbumSetView.setPressedUp();
		}
	}

	public void onLongTap(int slotIndex) {
		Log.d(TAG, "onLongTap");
		if (mGetContent || mGetAlbum)
			return;
		MediaSet set = mAlbumSetDataAdapter.getMediaSet(slotIndex);
		if (set == null)
			return;
		mSelectionManager.setAutoLeaveSelectionMode(true);
		mSelectionManager.toggle(set.getPath());
		mSlotView.invalidate();
	}

	@Override
	public void doCluster(int clusterType) {
		String basePath = mMediaSet.getPath().toString();
		String newPath = FilterUtils.switchClusterPath(basePath, clusterType);
		Log.d(TAG, "doCluster -- basePath : " + basePath + " newPath : "
				+ newPath);
		Bundle data = new Bundle(getData());
		data.putString(AlbumSetPage.KEY_MEDIA_PATH, newPath);
		data.putInt(KEY_SELECTED_CLUSTER_TYPE, clusterType);
		mActivity.getStateManager().switchState(this, AlbumSetPage.class, data);
	}

	@Override
	public void onCreate(Bundle data, Bundle restoreState) {
		super.onCreate(data, restoreState);
		Log.d(TAG, "onCreate()");

		initializeViews();
		initializeData(data);

		mContext = mActivity.getAndroidContext();
		mGetContent = data.getBoolean(GalleryActivity.KEY_GET_CONTENT, false);
		mGetAlbum = data.getBoolean(GalleryActivity.KEY_GET_ALBUM, false);
		mTitle = data.getString(AlbumSetPage.KEY_SET_TITLE);
		mSubtitle = data.getString(AlbumSetPage.KEY_SET_SUBTITLE);
		mEyePosition = new EyePosition(mContext, this);
		mDetailsSource = new MyDetailsSource();
		mActionBar = mActivity.getGalleryActionBar();
		// 默认Cluster类型
		mSelectedAction = data.getInt(AlbumSetPage.KEY_SELECTED_CLUSTER_TYPE,
				FilterUtils.CLUSTER_BY_TIME);

		mHandler = new SynchronizedHandler(mActivity.getGLRoot()) {
			@Override
			public void handleMessage(Message message) {
				switch (message.what) {
				case MSG_PICK_ALBUM: {
					pickAlbum(message.arg1);
					break;
				}
				default:
					throw new AssertionError(message.what);
				}
			}
		};
	}

	@Override
	public void onDestroy() {
		super.onDestroy();
		Log.d(TAG, "onDestroy()");
		cleanupCameraButton();
		mActionModeHandler.destroy();
	}

	private boolean setupCameraButton() {
		Log.d(TAG, "setupCameraButton()");
		if (!GalleryUtils.isCameraAvailable(mActivity))
			return false;
		RelativeLayout galleryRoot = (RelativeLayout) ((Activity) mActivity)
				.findViewById(R.id.gallery_root);
		if (galleryRoot == null) {
			return false;
		}

		mCameraButton = new Button(mActivity);
		mCameraButton.setText(R.string.camera_label);
		mCameraButton.setCompoundDrawablesWithIntrinsicBounds(0,
				R.drawable.frame_overlay_gallery_camera, 0, 0);
		mCameraButton.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View arg0) {
				GalleryUtils.startCameraActivity(mActivity);
			}
		});
		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(
				RelativeLayout.LayoutParams.WRAP_CONTENT,
				RelativeLayout.LayoutParams.WRAP_CONTENT);
		lp.addRule(RelativeLayout.CENTER_IN_PARENT);
		galleryRoot.addView(mCameraButton, lp);
		return true;
	}

	private void cleanupCameraButton() {
		if (mCameraButton == null)
			return;
		RelativeLayout galleryRoot = (RelativeLayout) ((Activity) mActivity)
				.findViewById(R.id.gallery_root);
		if (galleryRoot == null)
			return;
		galleryRoot.removeView(mCameraButton);
		mCameraButton = null;
	}

	private void showCameraButton() {
		if (mCameraButton == null && !setupCameraButton())
			return;
		mCameraButton.setVisibility(View.VISIBLE);
	}

	private void hideCameraButton() {
		if (mCameraButton == null)
			return;
		mCameraButton.setVisibility(View.GONE);
	}

	private void clearLoadingBit(int loadingBit) {
		mLoadingBits &= ~loadingBit;
		if (mLoadingBits == 0 && mIsActive) {
			if (mAlbumSetDataAdapter.size() == 0) {
				// If this is not the top of the gallery folder hierarchy,
				// tell the parent AlbumSetPage instance to handle displaying
				// the empty album toast, otherwise show it within this
				// instance
				if (mActivity.getStateManager().getStateCount() > 1) {
					Intent result = new Intent();
					result.putExtra(AlbumPage.KEY_EMPTY_ALBUM, true);
					setStateResult(Activity.RESULT_OK, result);
					Log.d(TAG, "clearLoadingBit -- setStateResult");
					mActivity.getStateManager().finishState(this);
				} else {
					mShowedEmptyToastForSelf = true;
					showEmptyAlbumToast(Toast.LENGTH_LONG);
					mSlotView.invalidate();
					showCameraButton();
				}
				return;
			}
		}
		// Hide the empty album toast if we are in the root instance of
		// AlbumSetPage and the album is no longer empty (for instance,
		// after a sync is completed and web albums have been synced)
		if (mShowedEmptyToastForSelf) {
			mShowedEmptyToastForSelf = false;
			hideEmptyAlbumToast();
			hideCameraButton();
		}
	}

	private void setLoadingBit(int loadingBit) {
		mLoadingBits |= loadingBit;
	}

	@Override
	public void onPause() {
		super.onPause();
		Log.d(TAG, "onPause()");
		mIsActive = false;

		mAlbumSetDataAdapter.pause();
		mAlbumSetView.pause();
		mActionModeHandler.pause();
		mEyePosition.pause();
		DetailsHelper.pause();

		// Call disableClusterMenu to avoid receiving callback after paused.
		// Don't hide menu here otherwise the list menu will disappear earlier
		// than
		// the action bar, which is janky and unwanted behavior.
		// mActionBar.disableClusterMenu(false);
		if (mSyncTask != null) {
			mSyncTask.cancel();
			mSyncTask = null;
			clearLoadingBit(BIT_LOADING_SYNC);
		}
	}

	@Override
	public void onResume() {
		super.onResume();
		Log.d(TAG, "onResume()");
		mIsActive = true;
		setContentPane(mRootPane);

		// Set the reload bit here to prevent it exit this page in
		// clearLoadingBit().
		setLoadingBit(BIT_LOADING_RELOAD);

		mAlbumSetDataAdapter.resume();
		mAlbumSetView.resume();
		mEyePosition.resume();
		mActionModeHandler.resume();

		if (mShowClusterMenu) {
			mActionBar.enableClusterMenu(mSelectedAction, this);
		}
		if (!mInitialSynced) {
			setLoadingBit(BIT_LOADING_SYNC);
			mSyncTask = mMediaSet.requestSync(AlbumSetPage.this);
		}
	}

	private void initializeData(Bundle data) {
		Log.d(TAG, "initializeData");
		String mediaPath = data.getString(AlbumSetPage.KEY_MEDIA_PATH);
		// Path : /combo/{/local/all,/picasa/all}
		Log.d(TAG, "initializeData -- Path : " + mediaPath);
		// 获取内容加载器（LocalAlbumSet）
		mMediaSet = mActivity.getDataManager().getMediaSet(mediaPath);

		mSelectionManager.setSourceMediaSet(mMediaSet);
		// 数据加载器
		mAlbumSetDataAdapter = new AlbumSetDataLoader(mActivity, mMediaSet,
				DATA_CACHE_SIZE);
		// 设置监听
		mAlbumSetDataAdapter.setLoadingListener(new MyLoadingListener());
		//
		mAlbumSetView.setModel(mAlbumSetDataAdapter);
	}

	private void initializeViews() {
		Log.d(TAG, "initialzeViews");
		mSelectionManager = new SelectionManager(mActivity, true);
		mSelectionManager.setSelectionListener(this);

		mConfig = Config.AlbumSetPage.get(mActivity);
		mSlotView = new SlotView(mActivity, mConfig.slotViewSpec);

		mAlbumSetView = new AlbumSetSlotRenderer(mActivity, mSelectionManager,
				mSlotView, mConfig.labelSpec, mConfig.placeholderColor);
		// SlotView设置Render对象
		mSlotView.setSlotRenderer(mAlbumSetView);

		mSlotView.setListener(new SlotView.SimpleListener() {
			@Override
			public void onDown(int index) {
				Log.d(TAG, "SlotView -- onDown index : " + index);
				AlbumSetPage.this.onDown(index);
			}

			@Override
			public void onUp(boolean followedByLongPress) {
				Log.d(TAG, "SlotView -- onUp followedByLongPress : "
						+ followedByLongPress);
				AlbumSetPage.this.onUp(followedByLongPress);
			}

			@Override
			public void onSingleTapUp(int slotIndex) {
				Log.d(TAG, "SlotView -- onSingleTapUp index : " + slotIndex);
				AlbumSetPage.this.onSingleTapUp(slotIndex);
			}

			@Override
			public void onLongTap(int slotIndex) {
				Log.d(TAG, "SlotView -- onLongTap index : " + slotIndex);
				AlbumSetPage.this.onLongTap(slotIndex);
			}
		});

		mActionModeHandler = new ActionModeHandler(mActivity, mSelectionManager);
		mActionModeHandler.setActionModeListener(new ActionModeListener() {
			@Override
			public boolean onActionItemClicked(MenuItem item) {
				return onItemSelected(item);
			}
		});
		// 添加View
		mRootPane.addComponent(mSlotView);
	}

	@Override
	protected boolean onCreateActionBar(Menu menu) {
		Log.d(TAG, "onCreateActionBar()");
		// Activity activity = mActivity;

		mActionBar.setDisplayOptions(false, false);
		mActionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM);

		mActionBar.setCustomView(R.layout.title_bar);

		View titleView = mActionBar.getCustomView();

		titles = new TextView[2];
		titles[GalleryActionBar.FLAG_PHOTO] = (TextView) titleView
				.findViewById(R.id.title_photo);
		titles[GalleryActionBar.FLAG_ALBUM] = (TextView) titleView
				.findViewById(R.id.title_album);
		// titles[GalleryActionBar.FLAG_ALBUM]
		// .setOnClickListener(new OnItemTitleClick());
		// titles[GalleryActionBar.FLAG_PHOTO]
		// .setOnClickListener(new OnItemTitleClick());

		// mActionBar.get
		mActionBar.setDisplayShowCustomEnabled(true);

		// Activity activity = mActivity;
		// final boolean inAlbum = mActivity.getStateManager().hasStateClass(
		// AlbumPage.class);
		// MenuInflater inflater = getSupportMenuInflater();
		//
		// if (mGetContent) {
		// inflater.inflate(R.menu.pickup, menu);
		// int typeBits = mData.getInt(GalleryActivity.KEY_TYPE_BITS,
		// DataManager.INCLUDE_IMAGE);
		// mActionBar.setTitle(GalleryUtils.getSelectionModePrompt(typeBits));
		// } else if (mGetAlbum) {
		// inflater.inflate(R.menu.pickup, menu);
		// mActionBar.setTitle(R.string.select_album);
		// } else {
		// inflater.inflate(R.menu.albumset, menu);
		// boolean wasShowingClusterMenu = mShowClusterMenu;
		// mShowClusterMenu = !inAlbum;
		// boolean selectAlbums = !inAlbum
		// && mActionBar.getClusterTypeAction() == FilterUtils.CLUSTER_BY_ALBUM;
		// MenuItem selectItem = menu.findItem(R.id.action_select);
		// selectItem.setTitle(activity
		// .getString(selectAlbums ? R.string.select_album
		// : R.string.select_group));
		//
		// MenuItem cameraItem = menu.findItem(R.id.action_camera);
		// cameraItem.setVisible(GalleryUtils.isCameraAvailable(activity));
		//
		// FilterUtils.setupMenuItems(mActionBar, mMediaSet.getPath(), false);
		//
		// Intent helpIntent = HelpUtils.getHelpIntent(activity);
		//
		// MenuItem helpItem = menu.findItem(R.id.action_general_help);
		// helpItem.setVisible(helpIntent != null);
		// if (helpIntent != null)
		// helpItem.setIntent(helpIntent);
		//
		// mActionBar.setTitle(mTitle);
		// mActionBar.setSubtitle(mSubtitle);
		// if (mShowClusterMenu != wasShowingClusterMenu) {
		// if (mShowClusterMenu) {
		// mActionBar.enableClusterMenu(mSelectedAction, this);
		// } else {
		// mActionBar.disableClusterMenu(true);
		// }
		// }
		// }
		return true;
	}

	// -------------------------Titlebar start--

	public void selected(int index) {
		if (index < 0 || index > 1) {
			return;
		}
		if (index == previousIndex) {
			return;
		}
		if (index == GalleryActionBar.FLAG_PHOTO) {
			titles[GalleryActionBar.FLAG_PHOTO].setTextAppearance(mContext,
					R.style.title_selected_style);
			titles[GalleryActionBar.FLAG_ALBUM].setTextAppearance(mContext,
					R.style.title_normal_style);
			titles[GalleryActionBar.FLAG_ALBUM].startAnimation(displayAnim());
			titles[GalleryActionBar.FLAG_PHOTO].startAnimation(hideAnim());
		} else if (index == GalleryActionBar.FLAG_ALBUM) {
			titles[GalleryActionBar.FLAG_ALBUM].setTextAppearance(mContext,
					R.style.title_selected_style);
			titles[GalleryActionBar.FLAG_PHOTO].setTextAppearance(mContext,
					R.style.title_normal_style);
			titles[GalleryActionBar.FLAG_PHOTO].startAnimation(displayAnim());
			titles[GalleryActionBar.FLAG_ALBUM].startAnimation(hideAnim());
		}
		previousIndex = index;
	}

	private Animation displayAnim() {
		Animation inAnim = new AlphaAnimation(1F, 0.5F);
		inAnim.setFillAfter(true);
		inAnim.setDuration(500);
		return inAnim;
	}

	private Animation hideAnim() {
		Animation outAnim = new AlphaAnimation(0.5F, 1F);
		outAnim.setDuration(500);
		outAnim.setFillAfter(true);
		return outAnim;
	}

	private class OnItemTitleClick implements OnClickListener {

		@Override
		public void onClick(View v) {
			switch (v.getId()) {
			case R.id.title_photo:
				selected(GalleryActionBar.FLAG_PHOTO);
				break;
			case R.id.title_album:
				selected(GalleryActionBar.FLAG_ALBUM);
				break;
			default:
				break;
			}
		}
	}

	// -------------------------Titlebar end--

	@Override
	protected boolean onItemSelected(MenuItem item) {
		Log.d(TAG, "onItemSelected -- item : " + item);
		Activity activity = mActivity;
		switch (item.getItemId()) {
		case R.id.action_cancel:
			activity.setResult(Activity.RESULT_CANCELED);
			activity.finish();
			return true;
		case R.id.action_select:
			mSelectionManager.setAutoLeaveSelectionMode(false);
			mSelectionManager.enterSelectionMode();
			return true;
		case R.id.action_details:
			if (mAlbumSetDataAdapter.size() != 0) {
				if (mShowDetails) {
					hideDetails();
				} else {
					showDetails();
				}
			} else {
				Toast.makeText(activity,
						activity.getText(R.string.no_albums_alert),
						Toast.LENGTH_SHORT).show();
			}
			return true;
		case R.id.action_camera: {
			GalleryUtils.startCameraActivity(activity);
			return true;
		}
		case R.id.action_manage_offline: {
			Bundle data = new Bundle();
			String mediaPath = mActivity.getDataManager().getTopSetPath(
					DataManager.INCLUDE_ALL);
			data.putString(AlbumSetPage.KEY_MEDIA_PATH, mediaPath);
			mActivity.getStateManager().startState(ManageCachePage.class, data);
			return true;
		}
		case R.id.action_sync_picasa_albums: {
			Toast.makeText(activity, "PicasaSource sync !", Toast.LENGTH_LONG)
					.show();
			// PicasaSource.requestSync(activity);
			return true;
		}
		case R.id.action_settings: {
			Toast.makeText(activity, "Gallery setting !", Toast.LENGTH_LONG)
					.show();
			// activity.startActivity(new Intent(activity,
			// GallerySettings.class));
			return true;
		}
		default:
			return false;
		}
	}

	@Override
	protected void onStateResult(int requestCode, int resultCode, Intent data) {
		Log.d(TAG, "onStateResult -- requestCode : " + requestCode
				+ " resultCode : " + resultCode);
		if (data != null
				&& data.getBooleanExtra(AlbumPage.KEY_EMPTY_ALBUM, false)) {
			showEmptyAlbumToast(Toast.LENGTH_SHORT);
		}
		switch (requestCode) {
		case REQUEST_DO_ANIMATION: {
			mSlotView.startRisingAnimation();
		}
		}
	}

	private String getSelectedString() {
		Log.d(TAG, "getSelectedString");
		int count = mSelectionManager.getSelectedCount();
		// int action = mActionBar.getClusterTypeAction();
		// int string = action == FilterUtils.CLUSTER_BY_ALBUM ?
		// R.plurals.number_of_albums_selected
		// : R.plurals.number_of_groups_selected;
		// String format = mActivity.getResources().getQuantityString(string,
		// count);
		// return String.format(format, count);
		return null;
	}

	@Override
	public void onSelectionModeChange(int mode) {
		Log.d(TAG, "onSelectionModeChange -- Mode : " + mode);
		switch (mode) {
		case SelectionManager.ENTER_SELECTION_MODE: {
			// mActionBar.disableClusterMenu(true);
			mActionModeHandler.startActionMode();
			performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
			break;
		}
		case SelectionManager.LEAVE_SELECTION_MODE: {
			mActionModeHandler.finishActionMode();
			if (mShowClusterMenu) {
				// mActionBar.enableClusterMenu(mSelectedAction, this);
			}
			mRootPane.invalidate();
			break;
		}
		case SelectionManager.SELECT_ALL_MODE: {
			mActionModeHandler.updateSupportedOperation();
			mRootPane.invalidate();
			break;
		}
		}
	}

	@Override
	public void onSelectionChange(Path path, boolean selected) {
		Log.d(TAG, "onSelectionChange()");
		mActionModeHandler.setTitle(getSelectedString());
		mActionModeHandler.updateSupportedOperation(path, selected);
	}

	private void hideDetails() {
		Log.d(TAG, "hideDetails");
		mShowDetails = false;
		mDetailsHelper.hide();
		mAlbumSetView.setHighlightItemPath(null);
		mSlotView.invalidate();
	}

	private void showDetails() {
		Log.d(TAG, "showDetails");
		mShowDetails = true;
		if (mDetailsHelper == null) {
			mDetailsHelper = new DetailsHelper(mActivity, mRootPane,
					mDetailsSource);
			mDetailsHelper.setCloseListener(new CloseListener() {
				@Override
				public void onClose() {
					hideDetails();
				}
			});
		}
		mDetailsHelper.show();
	}

	@Override
	public void onSyncDone(final MediaSet mediaSet, final int resultCode) {
		Log.d(TAG, "onSyncDone()");
		if (resultCode == MediaSet.SYNC_RESULT_ERROR) {
			Log.d(TAG, "onSyncDone: " + Utils.maskDebugInfo(mediaSet.getName())
					+ " result=" + resultCode);
		}
		((Activity) mActivity).runOnUiThread(new Runnable() {
			@Override
			public void run() {
				GLRoot root = mActivity.getGLRoot();
				root.lockRenderThread();
				try {
					if (resultCode == MediaSet.SYNC_RESULT_SUCCESS) {
						mInitialSynced = true;
					}
					clearLoadingBit(BIT_LOADING_SYNC);
					if (resultCode == MediaSet.SYNC_RESULT_ERROR && mIsActive) {
						Log.w(TAG, "failed to load album set");
					}
				} finally {
					root.unlockRenderThread();
				}
			}
		});
	}

	private class MyLoadingListener implements LoadingListener {
		@Override
		public void onLoadingStarted() {
			setLoadingBit(BIT_LOADING_RELOAD);
		}

		@Override
		public void onLoadingFinished(boolean loadingFailed) {
			clearLoadingBit(BIT_LOADING_RELOAD);
		}
	}

	private class MyDetailsSource implements DetailsHelper.DetailsSource {
		private int mIndex;

		@Override
		public int size() {
			return mAlbumSetDataAdapter.size();
		}

		@Override
		public int setIndex() {
			Path id = mSelectionManager.getSelected(false).get(0);
			mIndex = mAlbumSetDataAdapter.findSet(id);
			return mIndex;
		}

		@Override
		public MediaDetails getDetails() {
			MediaObject item = mAlbumSetDataAdapter.getMediaSet(mIndex);
			if (item != null) {
				mAlbumSetView.setHighlightItemPath(item.getPath());
				return item.getDetails();
			} else {
				return null;
			}
		}
	}
}
